/*******************************************************************
 *
 *  ttobjs.h                                                     1.0
 *
 *    Objects definition unit.
 *
 *  Copyright 1996-1999 by
 *  David Turner, Robert Wilhelm, and Werner Lemberg.
 *
 *  This file is part of the FreeType project, and may only be used
 *  modified and distributed under the terms of the FreeType project
 *  license, LICENSE.TXT.  By continuing to use, modify, or distribute
 *  this file you indicate that you have read the license and
 *  understand and accept it fully.
 *
 ******************************************************************/

#ifndef TTOBJS_H
#define TTOBJS_H

#include "ttconfig.h"
#include "ttengine.h"
#include "ttmutex.h"
#include "ttcache.h"
#include "tttables.h"
#include "ttcmap.h"

#ifdef __cplusplus
extern "C" {
#endif

	/*                                                                       */
	/*  This file contains the definitions and methods of the four           */
	/*  kinds of objects managed by the FreeType engine.  These are:         */
	/*                                                                       */
	/*                                                                       */
	/*   Face objects:                                                       */
	/*                                                                       */
	/*     There is always one face object per opened TrueType font          */
	/*     file, and only one.  The face object contains data that is        */
	/*     independent of current transform/scaling/rotation and             */
	/*     pointsize, or glyph index.  This data is made of several          */
	/*     critical tables that are loaded on face object creation.          */
	/*                                                                       */
	/*     A face object tracks all active and recycled objects of           */
	/*     the instance and execution context classes.  Destroying a face    */
	/*     object will automatically destroy all associated instances.       */
	/*                                                                       */
	/*                                                                       */
	/*   Instance objects:                                                   */
	/*                                                                       */
	/*     An instance object always relates to a given face object,         */
	/*     known as its 'parent' or 'owner', and contains only the           */
	/*     data that is specific to one given pointsize/transform of         */
	/*     the face.  You can only create an instance from a face object.    */
	/*                                                                       */
	/*     An instance's current transform/pointsize can be changed          */
	/*     at any time using a single high-level API call,                   */
	/*     TT_Reset_Instance().                                              */
	/*                                                                       */
	/*   Execution Context objects:                                          */
	/*                                                                       */
	/*     An execution context (or context in short) relates to a face.     */
	/*     It contains the data and tables that are necessary to load        */
	/*     and hint (i.e. execute the glyph instructions of) one glyph.      */
	/*     A context is a transient object that is queried/created on        */
	/*     the fly: client applications never deal with them directly.       */
	/*                                                                       */
	/*                                                                       */
	/*   Glyph objects:                                                      */
	/*                                                                       */
	/*     A glyph object contains only the minimal glyph information        */
	/*     needed to render one glyph correctly.  This means that a glyph    */
	/*     object really contains tables that are sized to hold the          */
	/*     contents of _any_ glyph of a given face.  A client application    */
	/*     can usually create one glyph object for a given face, then use    */
	/*     it for all subsequent loads.                                      */
	/*                                                                       */
	/*   Here is an example of a client application :                        */
	/*   (NOTE: No error checking performed here!)                           */
	/*                                                                       */
	/*                                                                       */
	/*     TT_Face       face;         -- face handle                        */
	/*     TT_Instance   ins1, ins2;   -- two instance handles               */
	/*     TT_Glyph      glyph;        -- glyph handle                       */
	/*                                                                       */
	/*     TT_Init_FreeType();                                               */
	/*                                                                       */
	/*     -- Initialize the engine.  This must be done prior to _any_       */
	/*        operation.                                                     */
	/*                                                                       */
	/*     TT_Open_Face( "/some/face/name.ttf", &face );                     */
	/*                                                                       */
	/*     -- create the face object.  This call opens the font file         */
	/*                                                                       */
	/*     TT_New_Instance( face, &ins1 );                                   */
	/*     TT_New_Instance( face, &ins2 );                                   */
	/*                                                                       */
	/*     TT_Set_Instance_PointSize( ins1, 8 );                             */
	/*     TT_Set_Instance_PointSize( ins2, 12 );                            */
	/*                                                                       */
	/*     -- create two distinct instances of the same face                 */
	/*     -- ins1  is pointsize 8 at resolution 96 dpi                      */
	/*     -- ins2  is pointsize 12 at resolution 96 dpi                     */
	/*                                                                       */
	/*     TT_New_Glyph( face, &glyph );                                     */
	/*                                                                       */
	/*     -- create a new glyph object which will receive the contents      */
	/*        of any glyph of 'face'                                         */
	/*                                                                       */
	/*     TT_Load_Glyph( ins1, glyph, 64, DEFAULT_GLYPH_LOAD );             */
	/*                                                                       */
	/*     -- load glyph indexed 64 at pointsize 8 in the 'glyph' object     */
	/*     -- NOTE: This call will fail if the instance and the glyph        */
	/*              do not relate to the same face object.                   */
	/*                                                                       */
	/*     TT_Get_Outline( glyph, &outline );                                */
	/*                                                                       */
	/*     -- extract the glyph outline from the object and copies it        */
	/*        to the 'outline' record                                        */
	/*                                                                       */
	/*     TT_Get_Metrics( glyph, &metrics );                                */
	/*                                                                       */
	/*     -- extract the glyph metrics and put them into the 'metrics'      */
	/*        record                                                         */
	/*                                                                       */
	/*     TT_Load_Glyph( ins2, glyph, 64, DEFAULT_GLYPH_LOAD );             */
	/*                                                                       */
	/*     -- load the same glyph at pointsize 12 in the 'glyph' object      */
	/*                                                                       */
	/*                                                                       */
	/*     TT_Close_Face( &face );                                           */
	/*                                                                       */
	/*     -- destroy the face object.  This will destroy 'ins1' and         */
	/*        'ins2'.  However, the glyph object will still be available     */
	/*                                                                       */
	/*     TT_Done_FreeType();                                               */
	/*                                                                       */
	/*     -- Finalize the engine.  This will also destroy all pending       */
	/*        glyph objects (here 'glyph').                                  */

	struct TFace_;
	struct TInstance_;
	struct TExecution_Context_;
	struct TGlyph_;

	typedef struct TFace_ TFace;
	typedef TFace *PFace;

	typedef struct TInstance_ TInstance;
	typedef TInstance *PInstance;

	typedef struct TExecution_Context_ TExecution_Context;
	typedef TExecution_Context *PExecution_Context;

	typedef struct TGlyph_ TGlyph;
	typedef TGlyph *PGlyph;

  /*************************************************************/
	/*                                                           */
	/*  ADDITIONAL SUBTABLES                                     */
	/*                                                           */
	/*  These tables are not precisely defined by the specs      */
	/*  but their structures is implied by the TrueType font     */
	/*  file layout.                                             */
	/*                                                           */
  /*************************************************************/

	/* Graphics State                            */
	/*                                           */
	/* The Graphics State (GS) is managed by the */
	/* instruction field, but does not come from */
	/* the font file.  Thus, we can use 'int's   */
	/* where needed.                             */

	struct TGraphicsState_ {
		UShort rp0;
		UShort rp1;
		UShort rp2;

		TT_UnitVector dualVector;
		TT_UnitVector projVector;
		TT_UnitVector freeVector;

		Long loop;
		TT_F26Dot6 minimum_distance;
		Int round_state;

		Bool auto_flip;
		TT_F26Dot6 control_value_cutin;
		TT_F26Dot6 single_width_cutin;
		TT_F26Dot6 single_width_value;
		Short delta_base;
		Short delta_shift;

		Byte instruct_control;
		Bool scan_control;
		Int scan_type;

		UShort gep0;
		UShort gep1;
		UShort gep2;
	};

	typedef struct TGraphicsState_ TGraphicsState;

	LOCAL_DEF const TGraphicsState Default_GraphicsState;

  /*************************************************************/
	/*                                                           */
	/*  EXECUTION SUBTABLES                                      */
	/*                                                           */
	/*  These sub-tables relate to instruction execution.        */
	/*                                                           */
  /*************************************************************/

#define MAX_CODE_RANGES   3

	/* There can only be 3 active code ranges at once:   */
	/*   - the Font Program                              */
	/*   - the CVT Program                               */
	/*   - a glyph's instructions set                    */

#define TT_CodeRange_Font  1
#define TT_CodeRange_Cvt   2
#define TT_CodeRange_Glyph 3

	struct TCodeRange_ {
		PByte Base;
		ULong Size;
	};

	typedef struct TCodeRange_ TCodeRange;
	typedef TCodeRange *PCodeRange;

	/* Defintion of a code range                                       */
	/*                                                                 */
	/* Code ranges can be resident to a glyph (i.e. the Font Program)  */
	/* while some others are volatile (Glyph instructions).            */
	/* Tracking the state and presence of code ranges allows function  */
	/* and instruction definitions within a code range to be forgotten */
	/* when the range is discarded.                                    */

	typedef TCodeRange TCodeRangeTable[MAX_CODE_RANGES];

	/* defines a function/instruction definition record */

	struct TDefRecord_ {
		Int Range;				/* in which code range is it located ? */
		ULong Start;			/* where does it start ?               */
		Int Opc;				/* function #, or instruction code     */
		Bool Active;			/* is it active ?                      */
	};

	typedef struct TDefRecord_ TDefRecord;
	typedef TDefRecord *PDefRecord;
	typedef TDefRecord *PDefArray;

	/* defines a call record, used to manage function calls. */

	struct TCallRecord_ {
		Int Caller_Range;
		ULong Caller_IP;
		Long Cur_Count;
		ULong Cur_Restart;
	};

	typedef struct TCallRecord_ TCallRecord;
	typedef TCallRecord *PCallRecord;
	typedef TCallRecord *PCallStack;	/* defines a simple call stack */

	/* This type defining a set of glyph points will be used to represent */
	/* each zone (regular and twilight) during instructions decoding.     */
	struct TGlyph_Zone_ {
		UShort n_points;		/* number of points in zone */
		Short n_contours;		/* number of contours       */

		TT_Vector *org;			/* original points coordinates */
		TT_Vector *cur;			/* current points coordinates  */

		Byte *touch;			/* current touch flags         */
		UShort *contours;		/* contour end points          */
	};

	typedef struct TGlyph_Zone_ TGlyph_Zone;
	typedef TGlyph_Zone *PGlyph_Zone;

#ifndef TT_STATIC_INTEPRETER	/* indirect implementation */

#define EXEC_OPS   PExecution_Context exc,
#define EXEC_OP    PExecution_Context exc
#define EXEC_ARGS  exc,
#define EXEC_ARG   exc

#else							/* static implementation */

#define EXEC_OPS				/* void */
#define EXEC_OP					/* void */
#define EXEC_ARGS				/* void */
#define EXEC_ARG				/* void */

#endif

	/* Rounding function, as used by the interpreter */
	typedef TT_F26Dot6(*TRound_Function) (EXEC_OPS TT_F26Dot6 distance, TT_F26Dot6 compensation);

	/* Point displacement along the freedom vector routine, as */
	/* used by the interpreter                                 */
	typedef void (*TMove_Function) (EXEC_OPS PGlyph_Zone zone, UShort point, TT_F26Dot6 distance);

	/* Distance projection along one of the proj. vectors, as used */
	/* by the interpreter                                          */
	typedef TT_F26Dot6(*TProject_Function) (EXEC_OPS TT_Vector * v1, TT_Vector * v2);

	/* reading a cvt value. Take care of non-square pixels when needed */
	typedef TT_F26Dot6(*TGet_CVT_Function) (EXEC_OPS ULong index);

	/* setting or moving a cvt value.  Take care of non-square pixels  */
	/* when needed                                                     */
	typedef void (*TSet_CVT_Function) (EXEC_OPS ULong index, TT_F26Dot6 value);

	/* subglyph transformation record */
	struct TTransform_ {
		TT_Fixed xx, xy;		/* transformation */
		TT_Fixed yx, yy;		/*     matrix     */
		TT_F26Dot6 ox, oy;		/*    offsets     */
	};

	typedef struct TTransform_ TTransform;
	typedef TTransform *PTransform;

	/* subglyph loading record.  Used to load composite components */
	struct TSubglyph_Record_ {
		Long index;				/* subglyph index; initialized with -1 */
		Bool is_scaled;			/* is the subglyph scaled?  */
		Bool is_hinted;			/* should it be hinted?     */
		Bool preserve_pps;		/* preserve phantom points? */

		Long file_offset;

		TT_Big_Glyph_Metrics metrics;

		TGlyph_Zone zone;

		Long arg1;				/* first argument  */
		Long arg2;				/* second argument */

		UShort element_flag;	/* current load element flag */

		TTransform transform;	/* transform */

		TT_Vector pp1, pp2;		/* phantom points */

	};

	typedef struct TSubglyph_Record_ TSubglyph_Record;
	typedef TSubglyph_Record *PSubglyph_Record;
	typedef TSubglyph_Record *PSubglyph_Stack;

	/* A note regarding non-squared pixels:                                */
	/*                                                                     */
	/* (This text will probably go into some docs at some time, for        */
	/*  now, it is kept there to explain some definitions in the           */
	/*  TIns_Metrics record).                                              */
	/*                                                                     */
	/* The CVT is a one-dimensional array containing values that           */
	/* control certain important characteristics in a font, like           */
	/* the height of all capitals, all lowercase letter, default           */
	/* spacing or stem width/height.                                       */
	/*                                                                     */
	/* These values are found in FUnits in the font file, and must be      */
	/* scaled to pixel coordinates before being used by the CVT and        */
	/* glyph programs.  Unfortunately, when using distinct x and y         */
	/* resolutions (or distinct x and y pointsizes), there are two         */
	/* possible scalings.                                                  */
	/*                                                                     */
	/* A first try was to implement a 'lazy' scheme where all values       */
	/* were scaled when first used.  However, while some values are always */
	/* used in the same direction, and some other are used in many         */
	/* different circumstances and orientations.                           */
	/*                                                                     */
	/* I have found a simpler way to do the same, and it even seems to     */
	/* work in most of the cases:                                          */
	/*                                                                     */
	/* - all CVT values are scaled to the maximum ppem size                */
	/*                                                                     */
	/* - when performing a read or write in the CVT, a ratio factor        */
	/*   is used to perform adequate scaling. Example:                     */
	/*                                                                     */
	/*    x_ppem = 14                                                      */
	/*    y_ppem = 10                                                      */
	/*                                                                     */
	/*   we choose ppem = x_ppem = 14 as the CVT scaling size.  All cvt    */
	/*   entries are scaled to it.                                         */
	/*                                                                     */
	/*    x_ratio = 1.0                                                    */
	/*    y_ratio = y_ppem/ppem (< 1.0)                                    */
	/*                                                                     */
	/*   we compute the current ratio like:                                */
	/*                                                                     */
	/*     - if projVector is horizontal,                                  */
	/*         ratio = x_ratio = 1.0                                       */
	/*     - if projVector is vertical,                                    */
	/*         ratop = y_ratio                                             */
	/*     - else,                                                         */
	/*         ratio = sqrt((proj.x*x_ratio)^2 + (proj.y*y_ratio)^2)       */
	/*                                                                     */
	/*   reading a cvt value returns      ratio * cvt[index]               */
	/*   writing a cvt value in pixels    cvt[index] / ratio               */
	/*                                                                     */
	/*   the current ppem is simply       ratio * ppem                     */
	/*                                                                     */

	/* metrics used by the instance and execution context objects */
	struct TIns_Metrics_ {
		TT_F26Dot6 pointSize;	/* point size.  1 point = 1/72 inch. */

		UShort x_resolution;	/* device horizontal resolution in dpi. */
		UShort y_resolution;	/* device vertical resolution in dpi.   */

		UShort x_ppem;			/* horizontal pixels per EM */
		UShort y_ppem;			/* vertical pixels per EM   */

		Long x_scale1;
		Long x_scale2;			/* used to scale FUnits to fractional pixels */

		Long y_scale1;
		Long y_scale2;			/* used to scale FUnits to fractional pixels */

		/* for non-square pixels */
		Long x_ratio;
		Long y_ratio;

		UShort ppem;			/* maximum ppem size */
		Long ratio;				/* current ratio     */
		Long scale1;
		Long scale2;			/* scale for ppem */

		TT_F26Dot6 compensations[4];	/* device-specific compensations */

		Bool rotated;			/* `is the glyph rotated?'-flag   */
		Bool stretched;			/* `is the glyph stretched?'-flag */
	};

	typedef struct TIns_Metrics_ TIns_Metrics;
	typedef TIns_Metrics *PIns_Metrics;

  /***********************************************************************/
	/*                                                                     */
	/*                         FreeType Face Type                          */
	/*                                                                     */
  /***********************************************************************/

	struct TFace_ {
		/* parent engine instance for the face object */
		PEngine_Instance engine;

		/* i/o stream */
		TT_Stream stream;

		/* used only by the threaded builds of the library */
		TMutex lock;

		/* TrueType collection header, if any was found */
		TTTCHeader ttcHeader;

		/* maximum profile table, as found in the TrueType file */
		TMaxProfile maxProfile;

		/* Note:                                          */
		/*  it seems that some maximum values cannot be   */
		/*  taken directly from this table, but rather by */
		/*  combining some of its fields; e.g. the max.   */
		/*  number of points seems to be given by         */
		/*  MAX( maxPoints, maxCompositePoints )          */
		/*                                                */
		/*  For this reason, we define later our own      */
		/*  max values that are used to load and allocate */
		/*  further tables.                               */

		TT_Header fontHeader;	/* the font header, as   */
		/* found in the TTF file */
		TT_Horizontal_Header horizontalHeader;	/* the horizontal header */

		Bool verticalInfo;		/* True when vertical table */
		TT_Vertical_Header verticalHeader;	/* is present in the font   */

		TT_OS2 os2;				/* 'OS/2' table */

		TT_Postscript postscript;	/* 'Post' table */

		TT_Hdmx hdmx;			/* 'Hdmx' table */

		TName_Table nameTable;	/* name table */

		TGasp gasp;				/* the 'gasp' table */

		/* The directory of TrueType tables for this typeface */
		UShort numTables;
		PTableDirEntry dirTables;

		/* The directory of character mappings table for */
		/* this typeface                                 */
		UShort numCMaps;
		PCMapTable cMaps;

		/* The glyph locations table */
		ULong numLocations;		/* UShort is not enough */
#ifndef TT_HUGE_PTR
		PStorage glyphLocations;
#else
		Storage TT_HUGE_PTR *glyphLocations;
#endif

		/* NOTE : The "hmtx" is now part of the horizontal header */

		/* the font program, if any */
		ULong fontPgmSize;
		PByte fontProgram;

		/* the cvt program, if any */
		ULong cvtPgmSize;
		PByte cvtProgram;

		/* the original, unscaled, control value table */
		ULong cvtSize;
		PShort cvt;

		/* The following values _must_ be set by the */
		/* maximum profile loader                    */

		UShort numGlyphs;		/* the face's total number of glyphs */
		UShort maxPoints;		/* max glyph points number, simple and composite */
		UShort maxContours;		/* max glyph contours numb, simple and composite */
		UShort maxComponents;	/* max components in a composite glyph */

		/* the following are object caches to track active */
		/* and recycled instances and execution contexts   */
		/* objects.  See 'ttcache.h'                       */

		TCache instances;		/* current instances for this face */
		TCache glyphs;			/* current glyph containers for this face */

		/* A typeless pointer to the face object extensions defined */
		/* in the 'ttextend.*' files.                               */
		void *extension;
		Int n_extensions;		/* number of extensions */

		/* Use extensions to provide additional capabilities to the */
		/* engine.  Read the developer's guide in the documentation */
		/* directory to know how to do that.                        */

		/* a generic pointer for client use - see TT_Set/Get_Face_Pointer */
		void *generic;
	};

  /***********************************************************************/
	/*                                                                     */
	/*                       FreeType Instance Type                        */
	/*                                                                     */
  /***********************************************************************/

	struct TInstance_ {
		PFace owner;			/* face object */

		Bool valid;

		TIns_Metrics metrics;

		UShort numFDefs;		/* number of function definitions */
		UShort maxFDefs;
		PDefArray FDefs;		/* table of FDefs entries         */

		UShort numIDefs;		/* number of instruction definitions */
		UShort maxIDefs;
		PDefArray IDefs;		/* table of IDefs entries            */

		Int maxFunc;			/* maximum function definition id    */
		Int maxIns;				/* maximum instruction definition id */

		TCodeRangeTable codeRangeTable;

		TGraphicsState GS;
		TGraphicsState default_GS;

		ULong cvtSize;			/* the scaled control value table */
		PLong cvt;

		ULong storeSize;		/* The storage area is now part of the */
		PLong storage;			/* instance                            */

		TGlyph_Zone twilight;	/* The instance's twilight zone */

		/* debugging variables */

		/* When using the debugger, we must keep the */
		/* execution context tied to the instance    */
		/* object rather than asking it on demand    */

		Bool debug;
		PExecution_Context context;

		/* a generic pointer for client use - see TT_Set/Get_Instance_Pointer */
		void *generic;
	};

  /***********************************************************************/
	/*                                                                     */
	/*                  FreeType Execution Context Type                    */
	/*                                                                     */
  /***********************************************************************/

	struct TExecution_Context_ {
		PFace face;
		PInstance instance;

		/* instructions state */

		TT_Error error;			/* last execution error */

		Long top;				/* top of exec. stack  */

		ULong stackSize;		/* size of exec. stack */
		PStorage stack;			/* current exec. stack */

		Long args;
		ULong new_top;			/* new top after exec.    */

		TGlyph_Zone zp0,		/* zone records */
		 zp1, zp2, pts, twilight;

		TIns_Metrics metrics;	/* instance metrics */

		TGraphicsState GS;		/* current graphics state */

		Int curRange;			/* current code range number   */
		PByte code;				/* current code range          */
		ULong IP;				/* current instruction pointer */
		ULong codeSize;			/* size of current range       */

		Byte opcode;			/* current opcode              */
		Int length;				/* length of current opcode    */

		Bool step_ins;			/* true if the interpreter must */
		/* increment IP after ins. exec */
		ULong cvtSize;
		PLong cvt;

		ULong glyphSize;		/* glyph instructions buffer size */
		PByte glyphIns;			/* glyph instructions buffer */

		UShort numFDefs;		/* number of function defs         */
		UShort maxFDefs;		/* maximum number of function defs */
		PDefRecord FDefs;		/* table of FDefs entries          */

		UShort numIDefs;		/* number of instruction defs         */
		UShort maxIDefs;		/* maximum number of instruction defs */
		PDefRecord IDefs;		/* table of IDefs entries             */

		Int maxFunc;
		Int maxIns;

		Int callTop,			/* top of call stack during execution */
		 callSize;				/* size of call stack */
		PCallStack callStack;	/* call stack */

		UShort maxPoints;		/* capacity of this context's "pts" */
		UShort maxContours;		/* record, expressed in points and  */
		/* contours..                       */

		TCodeRangeTable codeRangeTable;	/* table of valid coderanges */
		/* useful for the debugger   */

		ULong storeSize;		/* size of current storage */
		PLong storage;			/* storage area            */

		TT_F26Dot6 period;		/* values used for the */
		TT_F26Dot6 phase;		/* 'SuperRounding'     */
		TT_F26Dot6 threshold;

		/* this seems to be unused */
#if 0
		Int cur_ppem;			/* ppem along the current proj vector */
#endif
		Long scale1;			/* scaling values along the current   */
		Long scale2;			/* projection vector too..            */
		Bool cached_metrics;	/* the ppem is computed lazily. used  */
		/* to trigger computation when needed */

		Bool instruction_trap;	/* If True, the interpreter will */
		/* exit after each instruction   */

		TGraphicsState default_GS;	/* graphics state resulting from  */
		/* the prep program               */
		Bool is_composite;		/* ture if the glyph is composite */

		Bool pedantic_hinting;	/* if true, read and write array   */
		/* bounds faults halt the hinting  */

		/* latest interpreter additions */

		Long F_dot_P;			/* dot product of freedom and projection */
		/* vectors                               */
		TRound_Function func_round;	/* current rounding function             */

		TProject_Function func_project,	/* current projection function */
		 func_dualproj,			/* current dual proj. function */
		 func_freeProj;			/* current freedom proj. func  */

		TMove_Function func_move;	/* current point move function */

		TGet_CVT_Function func_read_cvt;	/* read a cvt entry              */
		TSet_CVT_Function func_write_cvt;	/* write a cvt entry (in pixels) */
		TSet_CVT_Function func_move_cvt;	/* incr a cvt entry (in pixels)  */

		ULong loadSize;
		PSubglyph_Stack loadStack;	/* loading subglyph stack */

	};

  /***********************************************************************/
	/*                                                                     */
	/*                  FreeType Glyph Object Type                         */
	/*                                                                     */
  /***********************************************************************/

	struct TGlyph_ {
		PFace face;
		TT_Big_Glyph_Metrics metrics;
		TT_Outline outline;
	};

	/* The following type is used to load a font from a collection. */
	/* See Face_Create in ttobjs.c                                  */

	struct TFont_Input_ {
		TT_Stream stream;		/* input stream                */
		ULong fontIndex;		/* index of font in collection */
		PEngine_Instance engine;	/* parent engine instance      */

	};

	typedef struct TFont_Input_ TFont_Input;

  /********************************************************************/
	/*                                                                  */
	/*   Code Range Functions                                           */
	/*                                                                  */
  /********************************************************************/

	/* Goto a specified coderange */
	LOCAL_DEF TT_Error Goto_CodeRange(PExecution_Context exec, Int range, ULong IP);

#if 0
	/* Return a pointer to a given coderange record. */
	/* Used only by the debugger.                    */
	LOCAL_DEF PCodeRange Get_CodeRange(PExecution_Context exec, Int range);
#endif

	/* Set a given code range properties */
	LOCAL_DEF TT_Error Set_CodeRange(PExecution_Context exec, Int range, void *base, ULong length);

	/* Clear a given coderange */
	LOCAL_DEF TT_Error Clear_CodeRange(PExecution_Context exec, Int range);

	LOCAL_DEF PExecution_Context New_Context(PFace face);

	LOCAL_DEF TT_Error Done_Context(PExecution_Context exec);

	LOCAL_DEF TT_Error Context_Load(PExecution_Context exec, PFace face, PInstance ins);

	LOCAL_DEF TT_Error Context_Save(PExecution_Context exec, PInstance ins);

	LOCAL_DEF TT_Error Context_Run(PExecution_Context exec, Bool debug);

	LOCAL_DEF TT_Error Instance_Init(PInstance ins);

	LOCAL_DEF TT_Error Instance_Reset(PInstance ins);

  /********************************************************************/
	/*                                                                  */
	/*   Handy scaling functions                                        */
	/*                                                                  */
  /********************************************************************/

	LOCAL_DEF TT_Pos Scale_X(PIns_Metrics metrics, TT_Pos x);
	LOCAL_DEF TT_Pos Scale_Y(PIns_Metrics metrics, TT_Pos y);

  /********************************************************************/
	/*                                                                  */
	/*   Component Initializer/Finalizer                                */
	/*                                                                  */
	/*   Called from 'freetype.c'                                       */
	/*   The component must create and register the face, instance and  */
	/*   execution context cache classes before any object can be       */
	/*   managed.                                                       */
	/*                                                                  */
  /********************************************************************/

	LOCAL_DEF TT_Error TTObjs_Init(PEngine_Instance engine);
	LOCAL_DEF TT_Error TTObjs_Done(PEngine_Instance engine);

#ifdef __cplusplus
}
#endif
#endif							/* TTOBJS_H */
/* END */
